﻿using System;
using System.Globalization;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Shapes;
using Sinacor.Infra.UI.Controls.SmartClient;
using Sinacor.Infra.UI.Common;
using PSE.Framework.UI.Resources;
using Sinacor.Infra.UI.Controls;
using Sinacor.UI.Bovespa.Movimento.Model;
using System.Windows.Threading;

namespace Sinacor.UI.Bovespa.Movimento.View.SmartClient
{
    /// <summary>
    /// Interaction logic for ControleMovimento.xaml
    /// </summary>
    public abstract partial class ControleMovimento : SinacorWindow, Presenter.IControleMovimentoView, Presenter.IControleMovimentoBolsa
    {
        #region Atributos
        private Model.Enum.TipoSistema _tipoSistema;
        private Presenter.IControleMovimento _presenterControleMovimento;

        #endregion

        #region Propriedades

        /// <summary>
        /// 
        /// </summary>

        public Presenter.IControleMovimento PresenterControleMovimento
        {

            get { return this._presenterControleMovimento; }
            set { this._presenterControleMovimento = value; }
        }

        #endregion

        #region Construtor

        /// <summary>
        /// 
        /// </summary>
        /// <param name="tipoSistema"></param>
        public ControleMovimento(Model.Enum.TipoSistema tipoSistema)
        {
            _tipoSistema = tipoSistema;
            InitializeComponent();

            if (tipoSistema == Model.Enum.TipoSistema.Ordens)
                _presenterControleMovimento = (Presenter.IControleMovimento)new Presenter.ControleMovimentoOrdens(this);
            else
                _presenterControleMovimento = (Presenter.IControleMovimento)new Presenter.ControleMovimentoBolsa(this);

            this.DataContext = this._presenterControleMovimento;
            this.AfterInitialize += new RoutedEventHandler(ControleMovimento_AfterInitialize);
        }

        #endregion

        #region Eventos

        #region AfterInitialize

        /// <summary>
        /// 
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void ControleMovimento_AfterInitialize(object sender, RoutedEventArgs e)
        {
            this.Inicializar();
        }

        #endregion

        #region Botões

        /// <summary>
        /// 
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnAbertura_Click(object sender, RoutedEventArgs e)
        {
            this.ShowUserWaitingProcess();

            if (_tipoSistema == Model.Enum.TipoSistema.Bolsa)
            {
                _presenterControleMovimento.AbrirMovimento();
            }
            else if (_tipoSistema == Model.Enum.TipoSistema.Ordens)
            {
                PresenterControleMovimento.AbrirMovimento();
            }
            this.HideUserWaitingProcess();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnReabertura_Click(object sender, RoutedEventArgs e)
        {
            this.ShowUserWaitingProcess();
            PresenterControleMovimento.ReabrirMovimento();
            this.HideUserWaitingProcess();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnSair_Click(object sender, RoutedEventArgs e)
        {
            this.PresenterControleMovimento.Sair();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void btnExecutar_Click(object sender, RoutedEventArgs e)
        {
            if (_tipoSistema == Model.Enum.TipoSistema.Bolsa)
            {                   
                if (rbtEfetuarConsolidacao.IsChecked.HasValue && (bool)this.rbtEfetuarConsolidacao.IsChecked)
                    _presenterControleMovimento.ConsolidarMovimento();
                else if (this.rbtFechamento.IsChecked.HasValue && (bool)this.rbtFechamento.IsChecked)
                    _presenterControleMovimento.FecharMovimento();
                else if (this.rbtSimularFechamento.IsChecked.HasValue && (bool)this.rbtSimularFechamento.IsChecked)
                    _presenterControleMovimento.SimularFechamentoMovimento();
            }
            else if (_tipoSistema == Model.Enum.TipoSistema.Ordens)
            {
                this.ShowUserWaitingProcess();

                if (this.rbtEfetuarConsolidacao.IsChecked.HasValue && (bool)this.rbtEfetuarConsolidacao.IsChecked)
                    this.PresenterControleMovimento.ConsolidarMovimento();
                else if (this.rbtSimularFechamento.IsChecked.HasValue && (bool)this.rbtSimularFechamento.IsChecked)
                    this.PresenterControleMovimento.SimularFechamentoMovimento();
                else if (this.rbtFechamento.IsChecked.HasValue && (bool)this.rbtFechamento.IsChecked)
                    this.PresenterControleMovimento.FecharMovimento();

                this.HideUserWaitingProcess();
            }
        }

        #endregion

        #endregion

        #region Métodos Privados

        #region Inicializar

        /// <summary>
        /// 
        /// </summary>
        private void Inicializar()
        {
            this.PresenterControleMovimento.Inicializar();
        }

        #endregion

        #region Exibição de Mensagens

        /// <summary>
        /// 
        /// </summary>
        /// <param name="resourceKey"></param>
        /// <returns></returns>
        private bool ExibirMensagemConfirmacao(string resourceKey)
        {
            SinacorMessageBoxResult result = SinacorMessageBox.Show(this.RetornarMensagemExibicaoFormatada(resourceKey), SinacorMessageBoxButton.YesNo, SinacorMessageBoxImage.Question);
            return (result == SinacorMessageBoxResult.Yes);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="resourceKey"></param>
        /// <returns></returns>
        public string RetornarMensagemExibicaoFormatada(string resourceKey)
        {
            switch (resourceKey)
            {
                case "Bovespa.Movimento.Message.ConfirmaAberturaMovimento":
                    return string.Format((string)ResourceProviderManager.GetResourceProvider().TryGetResource(resourceKey), ((DateTime)this.dtpDataMovimentoD1.Value).ToShortDateString());
                case "Bovespa.Movimento.Message.ConfirmaExecucaoFechamentoMovimentoOrdens":
                case "Bovespa.Movimento.Message.ConfirmaSimulacaoFechamento":
                case "Bovespa.Movimento.Message.ConfirmaConsolidacaoMovimento":
                case "Bovespa.Movimento.Message.ConfirmaReaberturaMovimento":
                case "Bovespa.Movimento.Message.MovimentoFechadoPodeSerAberto":
                case "Bovespa.Movimento.Message.MoviimentoFechado":
                case "Bovespa.Movimento.Label.MsgAlertaFechamentoConsolidacaoMovBolsa":
                case "Bovespa.Movimento.Message.ConsSimulFechMov":
                case "Bovespa.Movimento.Label.MovimentoProcessoFechamento":
                    return string.Format((string)ResourceProviderManager.GetResourceProvider().TryGetResource(resourceKey), ((DateTime)this.dtpDataMovimentoD0.Value).ToShortDateString());

                case "Bovespa.Movimento.Message.MovimentoFechadoPodeSerAbertoReaberto":
                    return string.Format((string)ResourceProviderManager.GetResourceProvider().TryGetResource(resourceKey), ((DateTime)this.dtpDataMovimentoD0.Value).ToShortDateString(), ((DateTime)this.dtpDataMovimentoD1.Value).ToShortDateString(), ((DateTime)this.dtpDataMovimentoD0.Value).ToShortDateString());

                case "Bovespa.Movimento.Message.ConfirmarAtencaoAberturaMovimento":
                    return string.Format((string)ResourceProviderManager.GetResourceProvider().TryGetResource(resourceKey), ((DateTime)this.dtpDataMovimentoD0.Value).ToShortDateString(), ((DateTime)this.dtpDataMovimentoD1.Value).ToShortDateString());

                default:
                    return (string)ResourceProviderManager.GetResourceProvider().TryGetResource(resourceKey);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="resourceKey"></param>
        private void ExibirMensagem(string resourceKey, SinacorMessageBoxImage image)
        {
            this.Dispatcher.BeginInvoke((Action)delegate()
            {
                SinacorMessageBox.Show(this.RetornarMensagemExibicaoFormatada(resourceKey), image);
            });            
        }

        #endregion

        #region PrepararTelaMovimentoOrdens

        /// <summary>
        /// 
        /// </summary>
        /// <param name="tipoMovimento"></param>
        private void PrepararTelaMovimentoOrdens(Model.Enum.TipoMovimento tipoMovimento)
        {
            if (tipoMovimento == Model.Enum.TipoMovimento.Abertura)
            {
                expPrincipal.Header = this.RetornarMensagemExibicaoFormatada("Bovespa.Movimento.Label.AberturaMovimentoOrdens");
                txbInformacao.Text = this.RetornarMensagemExibicaoFormatada("Bovespa.Movimento.Message.MovimentoFechadoPodeSerAberto");
                grbOpcoes.Visibility = Visibility.Collapsed;
                btnAbertura.Visibility = Visibility.Visible;
                btnReabertura.Visibility = Visibility.Collapsed;
                btnExecutar.Visibility = Visibility.Collapsed;
                btnSair.Visibility = Visibility.Visible;
            }
            else if (tipoMovimento == Model.Enum.TipoMovimento.Fechamento)
            {
                expPrincipal.Header = this.RetornarMensagemExibicaoFormatada("Bovespa.Movimento.Label.FechamentoConsolidacaoMovOrdens");
                txbInformacao.Text = this.RetornarMensagemExibicaoFormatada("Bovespa.Movimento.Label.MsgAlertaFechamentoConsolidacaoMovBolsa");
                grbOpcoes.Visibility = Visibility.Visible;
                btnAbertura.Visibility = Visibility.Collapsed;
                btnReabertura.Visibility = Visibility.Collapsed;
                btnExecutar.Visibility = Visibility.Visible;
                btnSair.Visibility = Visibility.Visible;
                rbtFechamento.IsChecked = true;
            }
            else if (tipoMovimento == Model.Enum.TipoMovimento.Reabertura)
            {
                expPrincipal.Header = this.RetornarMensagemExibicaoFormatada("Bovespa.Movimento.Label.ReaberturaMovimentoOrdens");
                txbInformacao.Text = this.RetornarMensagemExibicaoFormatada("Bovespa.Movimento.Label.MovimentoProcessoFechamento");
                grbOpcoes.Visibility = Visibility.Collapsed;
                btnAbertura.Visibility = Visibility.Collapsed;
                btnReabertura.Visibility = Visibility.Visible;
                btnExecutar.Visibility = Visibility.Collapsed;
                btnSair.Visibility = Visibility.Visible;
            }
            else //Abertura Reabertura
            {
                expPrincipal.Header = this.RetornarMensagemExibicaoFormatada("Bovespa.Movimento.Label.ReaberturaAberturaMovimento");
                txbInformacao.Text = this.RetornarMensagemExibicaoFormatada("Bovespa.Movimento.Message.MovimentoFechadoPodeSerAbertoReaberto");
                grbOpcoes.Visibility = Visibility.Collapsed;
                btnAbertura.Visibility = Visibility.Visible;
                btnReabertura.Visibility = Visibility.Visible;
                btnExecutar.Visibility = Visibility.Collapsed;
                btnSair.Visibility = Visibility.Visible;
            }
        }

        #endregion

        #endregion

        #region IControleMovimentoView Members

        #region Métodos de Apresentação

        /// <summary>
        /// 
        /// </summary>
        public void ApresentarDataMovimento()
        {
            this.dtpDataMovimentoD0.UpdateTarget(SinacorDatePicker.ValueProperty);
        }

        /// <summary>
        /// 
        /// </summary>
        public void ApresentarDataAtual()
        {
            this.dtpDataAtual.UpdateTarget(SinacorDatePicker.ValueProperty);
        }

        /// <summary>
        /// 
        /// </summary>
        public void ApresentarDataMovimentoD1()
        {
            this.dtpDataMovimentoD1.UpdateTarget(SinacorDatePicker.ValueProperty);
        }

        #endregion

        #region Métodos de Mensagens de Confirmação

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public bool ConfirmarAberturaMovimentoOrdens()
        {
            return this.ExibirMensagemConfirmacao("Bovespa.Movimento.Message.ConfirmaAberturaMovimento");
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public bool ConfirmarConsolidacaoMovimentoOrdens()
        {
            return this.ExibirMensagemConfirmacao("Bovespa.Movimento.Message.ConfirmaConsolidacaoMovimento");
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public bool ConfirmarContinuidadeProcessoFechamento()
        {
            return this.ExibirMensagemConfirmacao("Bovespa.Movimento.Message.DesejaContinuarFechamento");
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public bool ConfirmarFechamentoMovimentoOrdens()
        {
            return this.ExibirMensagemConfirmacao("Bovespa.Movimento.Message.ConfirmaExecucaoFechamentoMovimentoOrdens");
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public bool ConfirmarReaberturaMovimentoOrdens()
        {
            return this.ExibirMensagemConfirmacao("Bovespa.Movimento.Message.ConfirmaReaberturaMovimento");
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public bool ConfirmarSaida()
        {
            return this.ExibirMensagemConfirmacao("Bovespa.Movimento.Message.ConfirmaSaida");
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public bool ConfirmarSimulacaoFechamentoMovimentoOrdens()
        {
            return this.ExibirMensagemConfirmacao("Bovespa.Movimento.Message.ConfirmaSimulacaoFechamento");
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public bool ConfirmarAberturaMovimentoOrdensAtencao()
        {
            return this.ExibirMensagemConfirmacao("Bovespa.Movimento.Message.ConfirmarAtencaoAberturaMovimento");
        }

        #endregion

        #region Métodos de Mensagens de Informação

        /// <summary>
        /// 
        /// </summary>
        public void InformarErroSimulacaoImpedeFechamentoOrdens()
        {
            this.ExibirMensagem("Bovespa.Movimento.ExceptionMessage.SimulacaoImpedeFechamento", SinacorMessageBoxImage.Exclamation);
        }

        /// <summary>
        /// 
        /// </summary>
        public void InformarErroSimulacaoNaoImpedeFechamento()
        {
            this.ExibirMensagem("Bovespa.Movimento.ExceptionMessage.SimulacaoNaoImpedeFechamento", SinacorMessageBoxImage.Exclamation);
        }

        /// <summary>
        /// 
        /// </summary>
        public void InformarSucessoAberturaMovimentoOrdens()
        {
            this.ExibirMensagem("Bovespa.Movimento.Message.OperacaoRealizadaSucesso", SinacorMessageBoxImage.Information);
            this.FecharTela();
        }

        /// <summary>
        /// 
        /// </summary>
        public void InformarSucessoFechamentoMovimentoOrdens()
        {
            this.ExibirMensagem("Bovespa.Movimento.Message.OperacaoRealizadaSucesso", SinacorMessageBoxImage.Information);
            this.FecharTela();
        }

        /// <summary>
        /// 
        /// </summary>
        public void InformarSucessoReaberturaMovimentoOrdens()
        {
            this.ExibirMensagem("Bovespa.Movimento.Message.OperacaoRealizadaSucesso", SinacorMessageBoxImage.Information);
            this.FecharTela();
        }

        /// <summary>
        /// 
        /// </summary>
        public void InformarSucessoSimulacaoOrdens()
        {
            this.ExibirMensagem("Bovespa.Movimento.Message.OperacaoRealizadaSucesso", SinacorMessageBoxImage.Information);
        }

        /// <summary>
        /// 
        /// </summary>
        public void InformarSucessoConsolidacaoMovimentoOrdens()
        {
            this.ExibirMensagem("Bovespa.Movimento.Message.OperacaoRealizadaSucesso", SinacorMessageBoxImage.Information);
            this.FecharTela();
        }


        #endregion

        #region Método Fechar Tela

        /// <summary>
        /// 
        /// </summary>
        public void FecharTela()
        {
            this.Close();
        }

        #endregion

        #region Métodos de Preparação da Tela

        /// <summary>
        /// 
        /// </summary>
        public void PrepararTelaAberturaMovimentoOrdens()
        {
            this.PrepararTelaMovimentoOrdens(Sinacor.UI.Bovespa.Movimento.Model.Enum.TipoMovimento.Abertura);
        }

        /// <summary>
        /// 
        /// </summary>
        public void PrepararTelaAberturaReaberturaMovimentoOrdens()
        {
            this.PrepararTelaMovimentoOrdens(Sinacor.UI.Bovespa.Movimento.Model.Enum.TipoMovimento.ProcessoFechamento);
        }

        /// <summary>
        /// 
        /// </summary>
        public void PrepararTelaFechamentoMovimentoOrdens()
        {
            this.PrepararTelaMovimentoOrdens(Sinacor.UI.Bovespa.Movimento.Model.Enum.TipoMovimento.Fechamento);
        }

        /// <summary>
        /// 
        /// </summary>
        public void PrepararTelaReaberturaMovimentoOrdens()
        {
            this.PrepararTelaMovimentoOrdens(Sinacor.UI.Bovespa.Movimento.Model.Enum.TipoMovimento.Reabertura);
        }

        #endregion

        #endregion

        #region IControleMovimentoBolsa Members

        public void AbrirAguarde()
        {
            this.ShowUserWaitingProcess();
        }

        public void AtualizarDatas()
        {
            this.dtpDataMovimentoD0.UpdateTarget(SinacorDatePicker.ValueProperty);
            this.dtpDataAtual.UpdateTarget(SinacorDatePicker.ValueProperty);
            this.dtpDataMovimentoD1.UpdateTarget(SinacorDatePicker.ValueProperty);
        }


        public bool ConfirmarAberturaMovimento()
        {
            string texto = string.Format(this.FindResource("Bovespa.Movimento.Message.ConfirmaAberturaMovimento").ToString(),
                ((Presenter.ControleMovimentoBolsa)_presenterControleMovimento).DataMovimentoD1.ToShortDateString());

            if (SinacorMessageBox.Show(texto, SinacorMessageBoxButton.YesNo, SinacorMessageBoxImage.Question) == SinacorMessageBoxResult.Yes)
                return true;
            else
                return false;
        }

        public bool ConfirmarConsolidacaoMovimento()
        {
            string texto = string.Format(this.FindResource("Bovespa.Movimento.Message.ConfirmaConsolidacaoMovimento").ToString(),
                ((Presenter.ControleMovimentoBolsa)_presenterControleMovimento).DataMovimento.ToShortDateString());

            if (SinacorMessageBox.Show(texto, SinacorMessageBoxButton.YesNo, SinacorMessageBoxImage.Question) == SinacorMessageBoxResult.Yes)
                return true;
            else
                return false;
        }

        public bool ConfirmarContinuacaoFechamento(string mensagem)
        {
            string texto = "";
            bool retorno = true;
            DispatcherOperation dispatchOp = this.Dispatcher.BeginInvoke((Action)delegate()
            {
                texto = string.Format(this.FindResource("Bovespa.Movimento.Message.ContinuarFechamento").ToString(), mensagem);
                if (SinacorMessageBox.Show(texto, SinacorMessageBoxButton.YesNo, SinacorMessageBoxImage.Question) == SinacorMessageBoxResult.Yes)
                    retorno = true;
                else
                    retorno = false;
            });
            while (dispatchOp.Wait() != DispatcherOperationStatus.Completed) { };
            return retorno;
        }

        public bool ConfirmarFechamentoMovimento()
        {
            string texto = string.Format(this.FindResource("Bovespa.Movimento.Message.ConfirmaExecucaoFechamentoMovimentoOrdens").ToString(),
                ((Presenter.ControleMovimentoBolsa)_presenterControleMovimento).DataMovimento.ToShortDateString());

            if (SinacorMessageBox.Show(texto, SinacorMessageBoxButton.YesNo, SinacorMessageBoxImage.Question) == SinacorMessageBoxResult.Yes)
                return true;
            else
                return false;
        }

        public bool ConfirmarReaberturaMovimento()
        {
            string texto = string.Format(this.FindResource("Bovespa.Movimento.Message.ConfirmaReaberturaMovimento").ToString(),
                ((Presenter.ControleMovimentoBolsa)_presenterControleMovimento).DataMovimento.ToShortDateString());

            if (SinacorMessageBox.Show(texto, SinacorMessageBoxButton.YesNo, SinacorMessageBoxImage.Question) == SinacorMessageBoxResult.Yes)
                return true;
            else
                return false;
        }

        public bool ConfirmarSimulacaoFechamento()
        {
            string texto = string.Format(this.FindResource("Bovespa.Movimento.Message.ConfirmaSimulacaoFechamento").ToString(),
             ((Presenter.ControleMovimentoBolsa)_presenterControleMovimento).DataMovimento.ToShortDateString());

            if (SinacorMessageBox.Show(texto, SinacorMessageBoxButton.YesNo, SinacorMessageBoxImage.Question) == SinacorMessageBoxResult.Yes)
                return true;
            else
                return false;
        }

        public bool ConfirmarSaidaa()
        {
            if (SinacorMessageBox.Show(FindResource("Bovespa.Movimento.Message.ConfirmaSaida").ToString(), SinacorMessageBoxButton.YesNo, SinacorMessageBoxImage.Question)
              == SinacorMessageBoxResult.Yes)
                return true;
            else
                return false;
        }

        public void FecharAguarde()
        {
            this.HideUserWaitingProcess();
        }

        public void InformarAberturaNaoEfetuada()
        {
            string texto = string.Format(this.FindResource("Bovespa.Movimento.Message.AberturaNaoEfetuada").ToString(),
                ((Presenter.ControleMovimentoBolsa)_presenterControleMovimento).DataMovimentoD1.ToShortDateString());
            SinacorMessageBox.Show(texto, SinacorMessageBoxButton.Ok, SinacorMessageBoxImage.Information);
        }

        public void InformarConsolidacaoNaoEfetuada()
        {
            string texto = string.Format(this.FindResource("Bovespa.Movimento.Message.ConsolidacaoNaoEfetuada").ToString(),
                ((Presenter.ControleMovimentoBolsa)_presenterControleMovimento).DataMovimentoD1.ToShortDateString());
            SinacorMessageBox.Show(texto, SinacorMessageBoxButton.Ok, SinacorMessageBoxImage.Information);
        }

        public void InformarErroInesperado()
        {
            this.Dispatcher.BeginInvoke((Action)delegate()
            {
                this.ExibirMensagem("Bovespa.Movimento.ExceptionMessage.ErroInesperadoAberturaMovBolsas", SinacorMessageBoxImage.Error);
            });
        }

        public void InformarFechamentoConcluido()
        {
            this.Dispatcher.BeginInvoke((Action)delegate()
            {
                this.ExibirMensagem("Bovespa.Movimento.Message.OperacaoRealizadaSucesso", SinacorMessageBoxImage.Information);
            });
        }

        public void InformarFechamentoNaoEfetuado()
        {
            string texto = string.Format(this.FindResource("Bovespa.Movimento.Message.FechamNaoEfetuado").ToString(),
                ((Presenter.ControleMovimentoBolsa)_presenterControleMovimento).DataMovimento.ToShortDateString());
            SinacorMessageBox.Show(texto, SinacorMessageBoxButton.Ok, SinacorMessageBoxImage.Information);
        }

        public void InformarMovimentoAberto()
        {
            this.Dispatcher.BeginInvoke((Action)delegate()
            {
                string texto = string.Format(this.FindResource("Bovespa.Movimento.Message.MovimentoAberto").ToString(),
                ((Presenter.ControleMovimentoBolsa)_presenterControleMovimento).DataMovimento.ToShortDateString());
                SinacorMessageBox.Show(texto, SinacorMessageBoxButton.Ok, SinacorMessageBoxImage.Information);
            });   
        }

        public void InformarMovimentoConsolidado()
        {
            this.Dispatcher.BeginInvoke((Action)delegate()
            {
                string texto = string.Format(this.FindResource("Bovespa.Movimento.Message.MovimentoConsolidado").ToString(),
                    ((Presenter.ControleMovimentoBolsa)_presenterControleMovimento).DataMovimento.ToShortDateString());
                SinacorMessageBox.Show(texto, SinacorMessageBoxButton.Ok, SinacorMessageBoxImage.Information);
            });
        }

        public void InformarReaberturaNaoEfetuada()
        {
            this.ExibirMensagem("Bovespa.Movimento.Message.FalhaReabertura", SinacorMessageBoxImage.Exclamation);
        }

        public void InformarSimulacaoConcluida()
        {
            this.Dispatcher.BeginInvoke((Action)delegate()
            {
                this.ExibirMensagem("FaturamentoBovespa.Movimento.Message.SucessoSimulacao", SinacorMessageBoxImage.Information);
            });
        }

        public void InformarSimulacaoNaoEfetuada()
        {
            string texto = string.Format(this.FindResource("Bovespa.Movimento.Message.SimNaoEfetuada").ToString(),
                ((Presenter.ControleMovimentoBolsa)_presenterControleMovimento).DataMovimento.ToShortDateString());
            SinacorMessageBox.Show(texto, SinacorMessageBoxButton.Ok, SinacorMessageBoxImage.Information);
        }

        public void InicializarObjetosMovimentoBolsa()
        {
            //Esse Método e chamado para verificar se o process esta funcionando
            //_presenterControleMovimento.AbrirMovimento();

            grbOpcoes.Visibility = Visibility.Collapsed;            
            rbtSimularFechamento.Visibility = Visibility.Collapsed;
            rbtEfetuarConsolidacao.Visibility = Visibility.Collapsed;
            rbtFechamento.Visibility = Visibility.Collapsed;

        }

        public void PrepararTelaAbertura()
        {
            expPrincipal.Header = this.RetornarMensagemExibicaoFormatada("FaturamentoBovespa.Movimento.Message.RaberturaMovimento");
            txbInformacao.Text = this.RetornarMensagemExibicaoFormatada("Bovespa.Movimento.Message.MovimentoFechadoPodeSerAberto");
            grbOpcoes.Visibility = Visibility.Collapsed;
            btnAbertura.Visibility = Visibility.Visible;
            btnReabertura.Visibility = Visibility.Visible;
            btnExecutar.Visibility = Visibility.Collapsed;
            btnSair.Visibility = Visibility.Visible;
        }

        public void PrepararTelaAberturaD1()
        {
            expPrincipal.Header = this.RetornarMensagemExibicaoFormatada("FaturamentoBovespa.Movimento.Message.AberturaMovimento");
            txbInformacao.Text = this.RetornarMensagemExibicaoFormatada("Bovespa.Movimento.Message.MovimentoFechadoPodeSerAbertoReaberto");
            grbOpcoes.Visibility = Visibility.Collapsed;
            btnAbertura.Visibility = Visibility.Visible;
            btnReabertura.Visibility = Visibility.Visible;
            btnExecutar.Visibility = Visibility.Collapsed;
            btnSair.Visibility = Visibility.Visible;
        }

        public void PrepararTelaConsolidacao()
        {
            expPrincipal.Header = this.RetornarMensagemExibicaoFormatada("FaturamentoBovespa.Movimento.Message.ConsMovFaturamento");
            txbInformacao.Text = this.RetornarMensagemExibicaoFormatada("Bovespa.Movimento.Message.ConsSimulFechMov");
            grbOpcoes.Visibility = Visibility.Visible;
            rbtSimularFechamento.Visibility = Visibility.Visible;
            rbtEfetuarConsolidacao.Visibility = Visibility.Visible;
            rbtFechamento.Visibility = Visibility.Collapsed;
            btnAbertura.Visibility = Visibility.Collapsed;
            btnReabertura.Visibility = Visibility.Collapsed;
            btnExecutar.Visibility = Visibility.Visible;
            btnSair.Visibility = Visibility.Visible;
            rbtSimularFechamento.IsChecked = true;
        }

        public void PrepararTelaFechamento()
        {
            expPrincipal.Header = this.RetornarMensagemExibicaoFormatada("FaturamentoBovespa.Movimento.Message.FechaMovFaturamento");
            txbInformacao.Text = this.RetornarMensagemExibicaoFormatada("Bovespa.Movimento.Label.MsgAlertaFechamentoConsolidacaoMovBolsa");
            grbOpcoes.Visibility = Visibility.Visible;
            rbtSimularFechamento.Visibility = Visibility.Visible;
            rbtEfetuarConsolidacao.Visibility = Visibility.Visible;
            rbtFechamento.Visibility = Visibility.Visible;
            btnAbertura.Visibility = Visibility.Collapsed;
            btnReabertura.Visibility = Visibility.Collapsed;
            btnExecutar.Visibility = Visibility.Visible;
            btnSair.Visibility = Visibility.Visible;
            rbtSimularFechamento.IsChecked = true;
        }

        public void PrepararTelaReabertura()
        {
            expPrincipal.Header = this.RetornarMensagemExibicaoFormatada("FaturamentoBovespa.Movimento.Message.ReaberturaFaturamento");
            txbInformacao.Text = this.RetornarMensagemExibicaoFormatada("Bovespa.Movimento.Message.MoviimentoFechado");
            grbOpcoes.Visibility = Visibility.Collapsed;
            btnAbertura.Visibility = Visibility.Collapsed;
            btnReabertura.Visibility = Visibility.Visible;
            btnExecutar.Visibility = Visibility.Collapsed;
            btnSair.Visibility = Visibility.Visible;
        }
        public void AtualizarErrosServico() 
        {
            this.Dispatcher.BeginInvoke((Action)delegate()
            {
                this.ClearServiceErrors();
            });
        }
        #endregion
    }
}